home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / bin / gcc-config < prev    next >
Text File  |  2006-05-08  |  18KB  |  694 lines
  1. #!/bin/bash
  2. # Copyright 1999-2006 Gentoo Foundation
  3. # Distributed under the terms of the GNU General Public License v2
  4. # $Header: /var/cvsroot/gentoo-x86/sys-devel/gcc-config/files/gcc-config-1.3.13,v 1.7 2006/04/25 00:20:17 vapier Exp $
  5.  
  6. trap ":" INT QUIT TSTP
  7.  
  8. argv0=${0##*/}
  9. source /sbin/functions.sh || {
  10.     echo "${argv0}: Could not source /sbin/functions.sh!"
  11.     exit 1
  12. }
  13. umask 022
  14.  
  15. usage() {
  16. cat << "USAGE_END"
  17. Usage: gcc-config [options] [CC Profile]
  18. Change the current cc/gcc profile, or give info about profiles.
  19.  
  20. Options:
  21.   -O, --use-old              Use the old profile if one was selected.
  22.   -f, --force                Make sure all config files are regenerated.
  23.   -P, --use-portage-chost    Only set to given profile if its CHOST is the 
  24.                              same as that set for portage in /etc/make.conf
  25.                              (or one of other portage config files...).
  26.   -c, --get-current-profile  Print current used gcc profile.
  27.   -l, --list-profiles        Print a list of available profiles.
  28.   -S, --split-profile        Split profiles into their components
  29.   -E, --print-environ        Print environment that can be used to setup the
  30.                              current gcc profile, or a specified one.
  31.   -B, --get-bin-path         Print path where binaries of the given/current
  32.                              profile are located.
  33.   -L, --get-lib-path         Print path where libraries of the given/current
  34.                              profile are located.
  35.   -X, --get-stdcxx-incdir    Print path where g++ include files of the
  36.                              given/current profile are located.
  37.  
  38. Profile names are of the form:  <CHOST>-<gcc version>
  39. For example:                    i686-pc-linux-gnu-3.2.1
  40. USAGE_END
  41.     exit $1
  42. }
  43. [[ $# -lt 1 ]] && usage 1
  44.  
  45. find_path() {
  46.     [[ -z $1 ]] && return 0
  47.  
  48.     local fullpath="$(type -P $1)"
  49.     
  50.     if [[ -x ${fullpath} ]] ; then
  51.         echo "${fullpath}"
  52.         return 0
  53.     fi
  54.  
  55.     for x in /bin /sbin /usr/bin /usr/sbin /usr/local/bin /usr/local/sbin ; do
  56.         if [[ -x ${x}/$1 ]] && [[ -r ${x}/$1 ]] ; then
  57.             echo "${x}/$1"
  58.             return 0
  59.         fi
  60.     done
  61.  
  62.     return 0
  63. }
  64.  
  65. cmd_setup() {
  66.     # Sourcing /etc/env.d/gcc/${CC_COMP} is going to mess up
  67.     # PATH among things...
  68.     CP=$(find_path cp)
  69.     RM=$(find_path rm)
  70.     MV=$(find_path mv)
  71.     LN=$(find_path ln)
  72.     CAT=$(find_path cat)
  73.     ENV=$(find_path env)
  74.     SED=$(find_path sed)
  75.     AWK=$(find_path gawk)
  76.     GREP=$(find_path grep)
  77.     FIND=$(find_path find)
  78.     CHMOD=$(find_path chmod)
  79.     TOUCH=$(find_path touch)
  80.     PYTHON=$(find_path python)
  81.     PORTAGEQ=$(find_path portageq)
  82.     ENV_UPDATE=$(find_path env-update)
  83. }
  84.  
  85. cheap_portageq_envvar() {
  86.     local varname=$1
  87.     local conf=${ROOT}/etc/make.conf
  88.     local ret=$(source "${conf}" 2>/dev/null ; echo ${!varname})
  89.     if [[ -z ${ret} ]] ; then
  90.         # newer portage supports spaces between the var and =
  91.         # CHOST     =  "this-is-retarded"
  92.         ret=$(eval $(
  93.             ${SED} -n \
  94.                 -e 's:[[:space:]]::g' \
  95.                 -e '/^CHOST=/p' \
  96.                 "${conf}"
  97.             ) ; echo ${!varname}
  98.         )
  99.     fi
  100.     echo ${ret}
  101. }
  102.  
  103. get_real_chost() {
  104.     [[ -n ${REAL_CHOST} ]] && return 0
  105.  
  106.     # shortcut for switching compilers in a cross chroot
  107.     if [[ -n ${CHOST} && ${ROOT} != "/" ]] ; then
  108.         REAL_CHOST=${CHOST}
  109.         return 0
  110.     fi
  111.  
  112.     # make sure portage isnt broken
  113.     if ${PYTHON} -V &>/dev/null ; then
  114.         export REAL_CHOST=$(${ENV} -i ${PORTAGEQ} envvar CHOST 2>/dev/null)
  115.     else
  116.         export REAL_CHOST=$(cheap_portageq_envvar CHOST)
  117.     fi
  118.  
  119.     if [[ -z ${REAL_CHOST} ]] ; then
  120.         eerror "${argv0}: Could not get portage CHOST!"
  121.         eerror "${argv0}: You should verify that CHOST is set in one of these places:"
  122.         eerror "${argv0}:  - ${ROOT}/etc/make.conf"
  123.         eerror "${argv0}:  - active environment"
  124.         exit 1
  125.     fi
  126. }
  127.  
  128. is_cross_compiler() {
  129.     get_real_chost
  130.     [[ ${CC_COMP/${REAL_CHOST}} == ${CC_COMP} ]]
  131. }
  132.  
  133. switch_profile() {
  134.     local MY_LDPATH=
  135.     local GCC_PROFILES=
  136.     local OLD_CC_COMP=
  137.     local GCC_BIN_PATH=
  138.  
  139.     if [[ "$(id -u)" -ne 0 ]] ; then
  140.         eerror "${argv0}: Must be root."
  141.         exit 1
  142.     fi
  143.  
  144.     if is_cross_compiler ; then
  145.         ebegin "Switching cross-compiler to ${CC_COMP}"
  146.     else
  147.         ebegin "Switching native-compiler to ${CC_COMP}"
  148.     fi
  149.  
  150.     # Sourcing /etc/env.d/gcc/${CC_COMP} is going to mess up
  151.     # PATH among things...
  152.     cmd_setup
  153.  
  154.     if ! is_cross_compiler ; then
  155.         # Order our profiles to have the default first ...
  156.         # We do this so that we can have them ordered with default
  157.         # first in /etc/ld.so.conf, as the logical is that all
  158.         # compilers for default CHOST will be used to compile stuff,
  159.         # and thus we want all their lib paths in /etc/ld.so.conf ...
  160.         get_real_chost
  161.         GCC_PROFILES="$(${FIND} "${GCC_ENV_D}" -maxdepth 1 -name "${REAL_CHOST}-*" -a ! -name "${CC_COMP}")"
  162.         GCC_PROFILES="${GCC_ENV_D}/${CC_COMP} ${GCC_PROFILES}"
  163.  
  164.         # Extract all LDPATH's for our CHOST
  165.         MY_LDPATH=""
  166.         for x in ${GCC_PROFILES} ; do
  167.             if [[ -f ${x} ]] ; then
  168.                 source "${x}"
  169.  
  170.                 # Handle LDPATH's that have multiple directories
  171.                 local old_IFS="${IFS}"
  172.                 export IFS=":"
  173.                 local sub_ldpath=
  174.                 for sub_ldpath in ${LDPATH} ; do
  175.                     if [[ -d ${sub_ldpath} ]] ; then
  176.                         if [[ ${MY_LDPATH/:${sub_ldpath}} == ${MY_LDPATH} ]] ; then
  177.                             MY_LDPATH="${MY_LDPATH}:${sub_ldpath}"
  178.                         fi
  179.                     fi
  180.                 done
  181.                 export IFS="${old_IFS}"
  182.             fi
  183.         done
  184.         MY_LDPATH="${MY_LDPATH:1}" # trim leading :
  185.     fi
  186.  
  187.     # Setup things properly again for this profile
  188.     unset GCC_SPECS LDPATH
  189.     source "${GCC_ENV_D}/${CC_COMP}"
  190.     OLD_CC_COMP=$(get_current_profile)
  191.     CTARGET="${CTARGET:-${REAL_CHOST}}"
  192.  
  193.     # What kind of env.d entry are we going to generate ?
  194.     if is_cross_compiler ; then
  195.         # Only keep PATH/ROOTPATH
  196.         ${AWK} '/^(PATH|ROOTPATH)=/ {print $0}' \
  197.             "${GCC_ENV_D}/${CC_COMP}" > "${ENV_D}/05gcc-${CTARGET}"
  198.  
  199.         echo "CURRENT=${CC_COMP}" > "${GCC_ENV_D}/config-${CTARGET}"
  200.     else
  201.         # Pass all by default
  202.         ${AWK} '!/^(STDCXX_INCDIR|LDPATH|CC|CXX|CTARGET|GCCBITS|GCC_SPECS)=/ {print $0}' \
  203.             "${GCC_ENV_D}/${CC_COMP}" > "${ENV_D}/05gcc"
  204.         echo "LDPATH=\"${MY_LDPATH}\"" >> "${ENV_D}/05gcc"
  205.         if [[ -n ${GCC_SPECS} ]] && [[ -e ${ROOT}/${GCC_SPECS} ]] ; then
  206.             echo "GCC_SPECS=\"${GCC_SPECS}\"" >> "${ENV_D}/05gcc"
  207.         else
  208.             # People need to rebuild their gcc or setting GCC_SPECS to
  209.             # "" will cause issues again :(
  210.             if [[ ${ROOT} != "/" ]] ; then
  211.                 echo "GCC_SPECS=\"\"" >> "${ENV_D}/05gcc"
  212.             else
  213.                 if ! GCC_SPECS="" /usr/bin/gcc -v &>/dev/null ; then
  214.                     echo
  215.                     ewarn "Your gcc has a bug with GCC_SPECS."
  216.                     ewarn "Please re-emerge gcc."
  217.                     ewarn "http://bugs.gentoo.org/show_bug.cgi?id=68395"
  218.                     echo
  219.                 else
  220.                     echo "GCC_SPECS=\"\"" >> "${ENV_D}/05gcc"
  221.                 fi
  222.             fi
  223.         fi
  224.  
  225.         echo "CURRENT=${CC_COMP}" > "${GCC_ENV_D}/config"
  226.     fi
  227.  
  228.     # Save PATH
  229.     GCC_BIN_PATH="${PATH}"
  230.     # Fix environment
  231.     source /etc/profile
  232.     umask 022
  233.     # Find the bin wrapper
  234.     local wrapper
  235.     for wrapper in lib lib lib64 lib32 lib ; do
  236.         wrapper="${ROOT}usr/${wrapper}/misc/gcc-config"
  237.         [[ -e ${wrapper} ]] && break
  238.     done
  239.  
  240.     # Update the wrappers for this profile
  241.     local native="gcc cpp cc c++ g++ f77 g77 gcj"
  242.     is_cross_compiler && native=""
  243.     for x in ${native} ${CTARGET}-{cpp,gcc,c++,g++,f77,g77,gcj} ; do
  244.         # Make sure we have no stale wrappers
  245.         ${RM} -f "${ROOT}/usr/bin/${x}"
  246.         [[ ${x:${#x}-3} == "gcc" || ${x:${#x}-3} == "g++" ]] \
  247.             && ${RM} -f "${ROOT}/usr/bin/${x}"{32,64}
  248.  
  249.         # Only install a wrapper if the binary exists ...
  250.         # We want to figure out the 'reference file' for each 
  251.         # wrapper (the binary we're 'wrapping') so that we can 
  252.         # sync mtimes together.  This makes things like ccache
  253.         # happy.  See Bug #70548 for more info.
  254.         local ref
  255.         case ${x} in
  256.             cc)  ref=${ROOT}/${GCC_BIN_PATH}/gcc;;
  257.             f77) ref=${ROOT}/${GCC_BIN_PATH}/g77;;
  258.             *)   ref=${ROOT}/${GCC_BIN_PATH}/${x};;
  259.         esac
  260.         if [[ -x ${ref} ]] ; then
  261.             ${CP} -f "${wrapper}" "${ROOT}/usr/bin/${x}"
  262.             ${TOUCH} -r "${ref}" "${ROOT}/usr/bin/${x}"
  263.  
  264.             # Install 32bit and 64bit wrappers if need be
  265.             # This should probably get folded back into the wrapper ...
  266.             if [[ ${x:${#x}-3} == "gcc" ]] || [[ ${x:${#x}-3} == "g++" ]] ; then
  267.                 for bits in ${GCCBITS} ; do
  268.                     ${CP} -f "${wrapper}" "${ROOT}/usr/bin/${x}${bits}"
  269.                 done
  270.             fi
  271.         fi
  272.     done
  273.     # Only install cpp if switching to a native one
  274.     if ! is_cross_compiler && [[ ${CTARGET} != *-solaris* ]] ; then
  275.         ${RM} -f "${ROOT}/lib/cpp"
  276.         ${CP} -f "${wrapper}" "${ROOT}/lib/cpp"
  277.     fi
  278.  
  279.     # We need to make sure that libgcc_s.so / libunwind.so make it into /lib.
  280.     # On many systems (x86/amd64/etc...), this will probably never matter, 
  281.     # but on other systems (arm/mips/etc...), this is quite critical.
  282.     # http://bugs.gentoo.org/60190
  283.     #
  284.     # The funky move magic is required for proper updating of in-use files.
  285.     if ! is_cross_compiler ; then
  286.         # Need to cut out extra paths in multilib case and pray the first path
  287.         # is the "root" multilib path ... maybe some day change this to use
  288.         # `gcc -print-file-name` ...
  289.         LDPATH=${LDPATH%%:*}
  290.         for multilib in $("${ROOT}/${GCC_BIN_PATH}"/gcc -print-multi-lib); do
  291.             multiarg=${multilib#*;}
  292.             multiarg=${multiarg/@/-}
  293.             multilibdir=${multilib%;*}
  294.             libdir="lib/"$("${ROOT}/${GCC_BIN_PATH}"/gcc ${multiarg} -print-multi-os-directory)
  295.             if mkdir -p "${ROOT}/${libdir}"/.gcc.config.new ; then
  296.                 for gcclib in gcc_s unwind ; do
  297.                     if [[ -n $(ls "${ROOT}/${LDPATH}/${multilibdir}"/lib${gcclib}.so.* 2>/dev/null) ]]; then
  298.                         ${CP} -pP "${ROOT}/${LDPATH}/${multilibdir}"/lib${gcclib}.so.* "${ROOT}/${libdir}"/.gcc.config.new/
  299.                         ${RM} -f "${ROOT}/${libdir}"/lib${gcclib}.so*
  300.                         ${MV} -f "${ROOT}/${libdir}"/.gcc.config.new/* "${ROOT}/${libdir}"/
  301.                     fi
  302.                 done
  303.                 rmdir "${ROOT}/${libdir}"/.gcc.config.new
  304.             fi
  305.         done
  306.         unset multilib
  307.         unset multilibdir
  308.         unset multiarg
  309.         unset libdir
  310.     fi
  311.  
  312.     if [[ ${ROOT} == "/" ]] && [[ ${OLD_CC_COMP} != ${CC_COMP} || ${FORCE} == "yes" ]] ; then
  313.         # in case python is broken ...
  314.         if ! ${ENV_UPDATE} ; then
  315.             echo ""
  316.             ewarn "env-update failed to work properly; making sure ld.so.conf paths"
  317.             ewarn "are setup properly.  Please rerun gcc-config with the -f option."
  318.             echo ""
  319.             ${GREP} -h ^LDPATH= "${ROOT}"/etc/env.d/05gcc \
  320.                 | ${SED} -e 's:^LDPATH=::' -e 's:"::g' -e 's|:|\n|g' \
  321.                 >> /etc/ld.so.conf
  322.             ldconfig
  323.         fi
  324.     fi
  325.  
  326.     eend 0
  327.  
  328.     if [[ ${ROOT} == "/" ]] && [[ ${OLD_CC_COMP} != ${CC_COMP} ]] ; then
  329.         echo
  330.         ewarn "If you intend to use the gcc from the new profile in an already"
  331.         ewarn "running shell, please remember to do:"
  332.         echo
  333.         ewarn "  # source /etc/profile"
  334.         echo
  335.     fi
  336.  
  337.     return 0
  338. }
  339.  
  340. get_current_profile() {
  341.     local conf="${GCC_ENV_D}/config"
  342.     if [[ -n ${CTARGET} ]] ; then
  343.         conf="${conf}-${CTARGET}"
  344.     elif [[ -n ${CC_COMP} ]] && is_cross_compiler ; then
  345.         conf="${conf}-${CC_COMP}"
  346.     fi
  347.  
  348.     if [[ ! -f ${conf} ]] ; then
  349.         eerror "${argv0}: No gcc profile is active!"
  350.         return 1
  351.     fi
  352.  
  353.     source "${conf}"
  354.  
  355.     if [[ -z ${CURRENT} ]] ; then
  356.         eerror "${argv0}: No gcc profile is active!"
  357.         return 1
  358.     elif [[ ! -f ${GCC_ENV_D}/${CURRENT} ]] ; then
  359.         eerror "${argv0}: Active gcc profile is invalid!"
  360.         return 1
  361.     fi
  362.  
  363.     echo "${CURRENT}"
  364.  
  365.     return 0
  366. }
  367.  
  368. list_profiles() {
  369.     local i=1
  370.  
  371.     if [[ ${ROOT} != "/" ]] ; then
  372.         echo "Using gcc-config info in ${ROOT}"
  373.     fi
  374.  
  375.     if [[ ! -f ${GCC_ENV_D}/config ]] ; then
  376.         eerror "${argv0}: No gcc profile is active; please select one!"
  377.     fi
  378.  
  379.     eval $(grep -s ^CURRENT= "${GCC_ENV_D}"/config)
  380.     CURRENT_NATIVE=${CURRENT}
  381.     local target=
  382.     for x in "${GCC_ENV_D}"/* ; do
  383.         if [[ -f ${x} ]] && [[ ${x/\/config} == ${x} ]] ; then
  384.             source "${x}"
  385.             if [[ ${target} != ${CTARGET} ]] ; then
  386.                 [[ -n ${target} ]] && echo
  387.                 target=${CTARGET}
  388.                 CTARGET=""
  389.             fi
  390.  
  391.             x=${x##*/}
  392.             if [[ ${x} == ${CURRENT_NATIVE} ]] ; then
  393.                 x="${x} ${GOOD}*${NORMAL}"
  394.             elif [[ -e ${GCC_ENV_D}/config-${target} ]] ; then
  395.                 source "${GCC_ENV_D}/config-${target}"
  396.                 [[ ${x} == ${CURRENT} ]] && x="${x} ${HILITE}*${NORMAL}"
  397.             fi
  398.             echo " [${i}] ${x}"
  399.             ((++i))
  400.         fi
  401.     done
  402. }
  403.  
  404. print_environ() {
  405.     local OLDPATH="${PATH}"
  406.     local ENV_CMD=
  407.     local SET_ELEMENT=
  408.  
  409.     source "${GCC_ENV_D}/${CC_COMP}"
  410.  
  411.     case ${SHELL} in
  412.         */csh|*/tsch)
  413.             ENV_CMD="setenv"
  414.             SET_ELEMENT=" "
  415.             ;;
  416.         *)
  417.             ENV_CMD="export"
  418.             SET_ELEMENT="="
  419.             ;;
  420.     esac
  421.  
  422.     echo "${ENV_CMD} PATH${SET_ELEMENT}\"${PATH}:${OLDPATH}\""
  423. }
  424.  
  425. get_bin_path() {
  426.     if [[ -e ${GCC_ENV_D}/${CC_COMP} ]] ; then
  427.         source "${GCC_ENV_D}/${CC_COMP}"
  428.         echo "${PATH}"
  429.     else
  430.         echo "no-config"
  431.         echo "${GCC_ENV_D}/${CC_COMP} doesnt exist" 1>&2
  432.     fi
  433.  
  434.     return 0
  435. }
  436.  
  437. get_lib_path() {
  438.     if [[ -e ${GCC_ENV_D}/${CC_COMP} ]] ; then
  439.         source "${GCC_ENV_D}/${CC_COMP}"
  440.         echo "${LDPATH}"
  441.     else
  442.         echo "no-config"
  443.         echo "${GCC_ENV_D}/${CC_COMP} doesnt exist" 1>&2
  444.     fi
  445.  
  446.     return 0
  447. }
  448.  
  449. get_stdcxx_incdir() {
  450.     if [[ -e ${GCC_ENV_D}/${CC_COMP} ]] ; then
  451.         source "${GCC_ENV_D}/${CC_COMP}"
  452.         echo "${LDPATH}/include/${STDCXX_INCDIR}"
  453.     else
  454.         echo "no-config"
  455.         echo "${GCC_ENV_D}/${CC_COMP} doesnt exist" 1>&2
  456.     fi
  457.  
  458.     return 0
  459. }
  460.  
  461. split_gcc_ver() {
  462.     # Split up the gcc profile into components:
  463.     # TARGET-VER[-specs] -> TARGET VER [specs]
  464.     # arm-linux-3.3.6 -> arm-linux 3.3.6
  465.     # x86_64-linux-4.0.1-pre1234 -> x86_64-linux 4.0.1-pre1234
  466.     # sh-linux-3.4.4-hardened -> sh-linux 3.4.4 hardened
  467.     #
  468.     # So below we will start at the end and run a small state machine ...
  469.     # specs [3]
  470.     #    accept everything
  471.     # specs -> version transition [3->2]
  472.     #    when we find a version component
  473.     # version [2]
  474.     #    accept only version components (see the regex)
  475.     # version -> target transition [2->1]
  476.     #    when we hit a non version component
  477.     # target [1]
  478.     #    accept everything we have left
  479.     #
  480.     echo "$@" | awk -F- '
  481.     function pushit(onme, pushee) {
  482.         return (onme == "" ? pushee : pushee"-"onme);
  483.     }
  484.     {
  485.         state=3
  486.         targ=""
  487.         ver=""
  488.         spec=""
  489.         for (i=NF; i > 0; --i) {
  490.             if (state >= 2) {
  491.                 if ($i ~ /^(alpha|beta|pre|rc|p)?[[:digit:].]+$/) {
  492.                     ver=pushit(ver, $i)
  493.                     state=2
  494.                 } else if (state == 3)
  495.                     spec=pushit(spec, $i)
  496.                 else
  497.                     state=1
  498.             }
  499.             if (state == 1)
  500.                 targ = pushit(targ, $i)
  501.         }
  502.  
  503.         if (targ == "") {
  504.             if (ver == "") {
  505.                 ver=spec
  506.                 spec=""
  507.             }
  508.             targ=ver
  509.             ver=""
  510.         }
  511.         print targ " " ver (spec != "" ? " " spec : "")
  512.     }'
  513. }
  514. chop_gcc_ver_spec() {
  515.     local splitTED=$(split_gcc_ver $@) # target ver spec
  516.     splitTED=${splitTED#* }            # ver spec
  517.     echo ${splitTED/ /-}               # ver-spec
  518. }
  519.  
  520. NEED_ACTION="yes"
  521. DOIT="switch_profile"
  522. CHECK_CHOST="no"
  523. FORCE="no"
  524.  
  525. CC_COMP=
  526. [[ -z ${ROOT} ]] && ROOT="/"
  527. [[ ${ROOT:0-1} != "/" ]] && ROOT="${ROOT}/"
  528. ENV_D="${ROOT}etc/env.d"
  529. GCC_ENV_D="${ENV_D}/gcc"
  530.  
  531. for x in "$@" ; do
  532.     case "${x}" in
  533.         # Only use specified compiler if one is not already selected.
  534.         -O|--use-old)
  535.             if get_current_profile &>/dev/null ; then
  536.                 CC_COMP="$(get_current_profile)"
  537.             else
  538.                 eerror "No profile selected, unable to utilize --use-old"
  539.                 exit 1
  540.             fi
  541.             ;;
  542.         -f|--force)
  543.             FORCE="yes"
  544.             ;;
  545.         -P|--use-portage-chost)
  546.             CHECK_CHOST="yes"
  547.             ;;
  548.         -c|--get-current-profile)
  549.             if [[ ${NEED_ACTION} == "yes" ]] ; then
  550.                 NEED_ACTION="no"
  551.                 DOIT="get_current_profile"
  552.             fi
  553.             ;;
  554.         -l|--list-profiles)
  555.             if [[ ${NEED_ACTION} == "yes" ]] ; then
  556.                 NEED_ACTION="no"
  557.                 DOIT="list_profiles"
  558.             fi
  559.             ;;
  560.         -S|--split-profile)
  561.             if [[ ( $1 != "-S" && $1 != "--split-profile" ) || $# -eq 1 ]] ; then
  562.                 usage 1
  563.             fi
  564.             shift # push -S out
  565.             for x in "$@" ; do
  566.                 split_gcc_ver ${x}
  567.             done
  568.             exit 0
  569.             ;;
  570.         -E|--print-environ)
  571.             if [[ ${NEED_ACTION} == "yes" ]] ; then
  572.                 NEED_ACTION="no"
  573.                 DOIT="print_environ"
  574.             fi
  575.             ;;
  576.         -B|--get-bin-path)
  577.             if [[ ${NEED_ACTION} == "yes" ]] ; then
  578.                 NEED_ACTION="no"
  579.                 DOIT="get_bin_path"
  580.             fi
  581.             ;;
  582.         -L|--get-lib-path)
  583.             if [[ ${NEED_ACTION} == "yes" ]] ; then
  584.                 NEED_ACTION="no"
  585.                 DOIT="get_lib_path"
  586.             fi
  587.             ;;
  588.         -X|--get-stdcxx-incdir)
  589.             if [[ ${NEED_ACTION} == "yes" ]] ; then
  590.                 NEED_ACTION="no"
  591.                 DOIT="get_stdcxx_incdir"
  592.             fi
  593.             ;;
  594.         -h|--help)
  595.             usage 0
  596.             ;;
  597.         -V|--version)
  598.             echo "gcc-config-1.3.13-r2"
  599.             exit 0
  600.             ;;
  601.         -*)
  602.             eerror "${argv0}: Invalid switch!  Run ${argv0} without parameters for help."
  603.             exit 1
  604.             ;;
  605.         *)
  606.             if [[ -z ${CC_COMP} ]] ; then
  607.                 if [[ -z $(echo ${x} | tr -d '[:digit:]') ]] ; then
  608.                     # User gave us a # representing the profile
  609.                     i=1
  610.                     for y in "${GCC_ENV_D}"/* ; do
  611.                         [[ -f ${y} ]] || continue
  612.                         [[ ${y/\/config} != ${y} ]] && continue
  613.  
  614.                         if [[ -f ${y} ]] && [[ ${x} == ${i} ]] ; then
  615.                             CC_COMP=${y##*/}
  616.                             break
  617.                         fi
  618.                         ((++i))
  619.                     done
  620.                 else
  621.                     # User gave us a full HOST-gccver
  622.                     x=${x##*/}
  623.                     if [[ ${DOIT} == "get_current_profile" && -z $(ls "${GCC_ENV_D}"/${x}-* 2>/dev/null) ]] || \
  624.                        [[ ${DOIT} != "get_current_profile" && ! -f ${GCC_ENV_D}/${x} ]]
  625.                     then
  626.                         # Maybe they just gave us a gccver ...
  627.                         get_real_chost
  628.                         if [[ -f ${GCC_ENV_D}/${REAL_CHOST}-${x} ]] ; then
  629.                             x=${REAL_CHOST}-${x}
  630.                         else
  631.                             eerror "${argv0}: Could not locate '$x' in '${GCC_ENV_D}/' !"
  632.                             exit 1
  633.                         fi
  634.                     fi
  635.                     CC_COMP=${x}
  636.                 fi
  637.             else
  638.                 eerror "${argv0}: Too many arguments!  Run ${argv0} without parameters for help."
  639.                 exit 1
  640.             fi
  641.             ;;
  642.     esac
  643. done
  644.  
  645. if [[ ${DOIT} == "switch_profile" ]] && [[ -z ${CC_COMP} ]] ; then
  646.     usage 1
  647. fi
  648.  
  649. cmd_setup
  650.  
  651. if [[ -z ${CC_COMP} ]] ; then
  652.     CC_COMP=$(get_current_profile)
  653.     if [[ $? -ne 0 ]] ; then
  654.         echo "${CC_COMP}"
  655.         list_profiles
  656.         exit 1
  657.     fi
  658. fi
  659.  
  660. if [[ ${DOIT} != "get_current_profile" ]] ; then
  661.     GCC_LIB=$(
  662.         source "${GCC_ENV_D}/${CC_COMP}"
  663.         echo ${LDPATH} | ${AWK} -F/ '{ print  "/"$2"/"$3"/"$4"/" }'
  664.     )
  665.  
  666.     CC_COMP_VERSION=$(chop_gcc_ver_spec ${CC_COMP})
  667.     CC_COMP_TARGET=${CC_COMP%-${CC_COMP_VERSION}*}
  668.  
  669.     if [[ ! -d ${ROOT}/${GCC_LIB}/${CC_COMP_TARGET}/${CC_COMP_VERSION} ]]; then
  670.         CC_COMP_VERSION=${CC_COMP_VERSION%-*}
  671.     fi
  672.  
  673.     if [[ ! -d ${ROOT}/${GCC_LIB}/${CC_COMP_TARGET}/${CC_COMP_VERSION} ]] || \
  674.        [[ ! -f ${GCC_ENV_D}/${CC_COMP} ]]
  675.     then
  676.         eerror "${argv0}: Profile does not exist or invalid setting for ${GCC_ENV_D}/${CC_COMP}" 1>&2
  677.         #exit 1
  678.     fi
  679. fi
  680.  
  681. if [[ ${CHECK_CHOST} == "yes" ]] ; then
  682.     # Chosen CHOST are not the same as the real CHOST according to
  683.     # make.conf, and --use-portage-chost option was given, so do nothing
  684.     get_real_chost
  685.     CC_COMP_VERSION=$(chop_gcc_ver_spec ${CC_COMP})
  686.     CC_COMP_TARGET=${CC_COMP:0:${#CC_COMP}-${#CC_COMP_VERSION}-1}
  687.     [[ ${CC_COMP_TARGET} != ${REAL_CHOST} ]] && exit 0
  688. fi
  689.  
  690. eval ${DOIT}
  691.  
  692.  
  693. # vim:ts=4
  694.